#pragma once
#pragma warning(disable:4996)
// dma.h -- inheritance and dynamic memory allocation
//#ifndef DMA_H_
//#define DMA_H_
//#include <iostream>
//
//// Base Class Using DMA
//class baseDMA
//{
//private:
//	char* label;
//	int rating;
//	
//public:
//	baseDMA(const char* l = "null", int r = 0);
//	baseDMA(const baseDMA& rs);
//	virtual ~baseDMA();
//	baseDMA& operator=(const baseDMA& rs);
//	friend std::ostream& operator<<(std::ostream& os,
//									const baseDMA& rs);
//};
//
//// derived class without DMA
//// no destructor needed
//// uses implicit copy constructor
//// uses implicit assignment operator
//class lacksDMA :public baseDMA
//{
//private:
//	enum
//	{
//		COL_LEN = 40
//	};
//	char color[COL_LEN];
//	
//public:
//	lacksDMA(const char* c = "blank", const char* l = "null",
//		int r = 0);
//	lacksDMA(const char* c, const baseDMA& rs);
//	friend std::ostream& operator<<(std::ostream& os,
//									const lacksDMA& rs);
//};
//
//// derived class with DMA
//class hasDMA :public baseDMA
//{
//private:
//	char* style;
//public:
//	hasDMA(const char* s = "none", const char* l = "null",
//			int r = 0);
//	hasDMA(const char* s, const baseDMA& rs);
//	hasDMA(const hasDMA& hs);
//	~hasDMA();
//	hasDMA& operator=(const hasDMA& rs);
//	friend std::ostream& operator<<(std::ostream& os,
//									const hasDMA& rs);
//};
//#endif // !DMA_H_

// studentc.h -- defining a Student class using containment
//#ifndef STUDENTC_H_
//#define STUDENTC_H_
//
//#include <iostream>
//#include <string>
//#include <valarray>
//class Student
//{
//private:
//	typedef std::valarray<double> ArrayDb;
//	std::string name;		// contained object
//	ArrayDb scores;			// contained object
//	// private method for scores output
//	std::ostream& arr_out(std::ostream& os) const;
//
//public:
//	Student() :name("Null Student"), scores() {}
//	explicit Student(const std::string& s) :name(s), scores() {}
//	explicit Student(int n) :name("Nully"), scores(n) {}
//	Student(const std::string& s, int n) :name(s), scores(n) {}
//	Student(const std::string& s, const ArrayDb& a) :name(s), scores(a) {}
//	Student(const char* str, const double* pd, int n) :name(str), scores(pd, n) {}
//	~Student() {}
//	double Average() const;
//	const std::string& Name() const;
//	double& operator[](int i);
//	double operator[](int i) const;
//// friends
//	// input
//	friend std::istream& operator>>(std::istream& is, Student& stu);	// 1 word
//	friend std::istream& getline(std::istream& is, Student& std);		// 1 line
//
//	// output
//	friend std::ostream& operator<<(std::ostream& os, const Student& std);
//};
//#endif // !STUDENTC_H_

// studenti.h -- defining a Student class using private inheritance
//#ifndef STUDENTC_H_
//#define STUDENTC_H_
//
//#include <iostream>
//#include <valarray>
//#include <string>
//class Student : private std::string, private std::valarray<double>
//{
//private:
//	typedef std::valarray<double> ArrayDb;
//	// private method for scores output
//	std::ostream& arr_out(std::ostream& os) const;
//public:
//	Student() :std::string("Null Student"), ArrayDb() {}
//	explicit Student(const std::string& s)
//		:std::string(s), ArrayDb() {}
//	explicit Student(int n) :std::string("Nully"), ArrayDb(n) {}
//	Student(const std::string& s, int n)
//		:std::string(s), ArrayDb(n) {}
//	Student(const std::string& s, const ArrayDb& a)
//		:std::string(s), ArrayDb(a) {}
//	Student(const char* str, const double* pd, int n)
//		:std::string(str), ArrayDb(pd, n) {}
//	~Student() {}
//	double Average() const;
//	double& operator[](int i);
//	double operator[](int i) const;
//	const std::string& Name() const;
//// friends
//	// input
//	friend std::istream& operator>>(std::istream& is, Student& std);	// 1 word
//	friend std::istream& getline(std::istream& is, Student& std);		// 1 line
//
//	// output
//	friend std::ostream& operator<<(std::ostream& os, const Student& stu);
//};
//#endif // !STUDENTC_H_

// workermi.h -- working classes with MI
//#ifndef WORKERMI_H_
//#define WORKERMI_H_
//
//#include <string>
//
//class Worker	// an abstract base class
//{
//private:
//	std::string fullname;
//	long id;
//protected:
//	virtual void Data() const;
//	virtual void Get();
//public:
//	Worker() :fullname("no one"), id(0L) {}
//	Worker(const std::string& s, long n) :fullname(s), id(n) {}
//	virtual ~Worker() = 0;		// pure virtual function
//	virtual void Set() = 0;
//	virtual void Show() const = 0;
//};
//
//class Waiter :virtual public Worker
//{
//private:
//	int panache;
//protected:
//	void Data() const;
//	void Get();
//public:
//	Waiter() :Worker(), panache(0) {}
//	Waiter(const std::string& s, long n, int p = 0)
//		:Worker(s, n), panache(p) {}
//	Waiter(const Worker& wk, int p = 0)
//		:Worker(wk), panache(p) {}
//	void Set();
//	void Show() const;
//};
//
//class Singer :virtual public Worker
//{
//protected:
//	enum {other, alto, contralto, soprano, bass, baritone, tenor};
//	enum {Vtypes = 7};
//	void Data() const;
//	void Get();
//private:
//	static const char* pv[Vtypes];	// string equivs of voice types
//	int voice;
//public:
//	Singer() :Worker(), voice(other) {}
//	Singer(const std::string& s, long n, int v = other)
//		:Worker(s, n), voice(v) {}
//	Singer(const Worker& wk, int v = other)
//		:Worker(wk), voice(v) {}
//	void Set();
//	void Show() const;
//};
//
//// multiple inheritance
//class SingingWaiter :public Singer, public Waiter
//{
//protected:
//	void Data() const;
//	void Get();
//public:
//	SingingWaiter() {}
//	SingingWaiter(const std::string& s, long n, int p = 0, int v = other)
//		:Worker(s, n), Waiter(s, n, p), Singer(s, n, v) {}
//	SingingWaiter(const Worker& wk, int p = 0, int v = other)
//		:Worker(wk), Waiter(wk, p), Singer(wk, v) {}
//	SingingWaiter(const Waiter& wt, int v = other)
//		:Worker(wt), Waiter(wt), Singer(wt, v) {}
//	SingingWaiter(const Singer& sg, int p = 0)
//		:Worker(sg), Waiter(sg, p), Singer(sg) {}
//	void Set();
//	void Show() const;
//};
//#endif // !WORKERMI_H_

// stacktp.h -- a stack template
//#ifndef STACKTP_H_
//#define STACKTP_H_
//
//template <class Type>
//class Stack
//{
//private:
//	enum { MAX = 10 };	// constant specific to class
//	Type items[MAX];	// holds stack items
//	int top;			// index for top stack item
//public:
//	Stack();
//	bool isempty();
//	bool isfull();
//	bool push(const Type& item);	// add item to stack
//	bool pop(Type& item);			// pop top into item
//};
//
//template <class Type>
//Stack<Type>::Stack()
//{
//	top = 0;
//}
//
//template <class Type>
//bool Stack<Type>::isempty()
//{
//	return top == 0;
//}
//
//template <class Type>
//bool Stack<Type>::isfull()
//{
//	return top == MAX;
//}
//
//template <class Type>
//bool Stack<Type>::push(const Type& item)
//{
//	if (top < MAX)
//	{
//		items[top++] = item;
//		return true;
//	}
//	else
//	{
//		return false;
//	}
//}
//
//template <class Type>
//bool Stack<Type>::pop(Type& item)
//{
//	if (top > 0)
//	{
//		item = items[--top];
//		return true;
//	}
//	else
//	{
//		return false;
//	}
//}
//#endif // !STACKTP_H_

// stcktp1.h -- modified Stack template
//#ifndef STCKTP1_H_
//#define STCKTP1_H_
//
//template <class Type>
//class Stack
//{
//private:
//	enum { SIZE = 10 };	// default size
//	int stacksize;
//	Type* items;		// holds stack items
//	int top;			// index for top stack item
//public:
//	explicit Stack(int ss = SIZE);
//	Stack(const Stack& st);
//	~Stack() { delete[] items; }
//	bool isempty() { return top == 0; }
//	bool isfull() { return top == stacksize; }
//	bool push(const Type& item);	// add item to stack
//	bool pop(Type& item);			// pop top into item
//	Stack& operator=(const Stack& st);
//};
//
//template <class Type>
//Stack<Type>::Stack(int ss) :stacksize(ss), top(0)
//{
//	items = new Type[stacksize];
//}
//
//template <class Type>
//Stack<Type>::Stack(const Stack& st)
//{
//	stacksize = st.stacksize;
//	top = st.top;
//	items = new Type[stacksize];
//	for (int i = 0; i < top; i++)
//	{
//		this->itmes[i] = st.items[i];
//	}
//}
//
//template <class Type>
//bool Stack<Type>::push(const Type& item)
//{
//	if (top < stacksize)
//	{
//		items[top++] = item;
//		return true;
//	}
//	else
//	{
//		return false;
//	}
//}
//
//template <class Type>
//bool Stack<Type>::pop(Type& item)
//{
//	if (top > 0)
//	{
//		item = items[--top];
//		return true;
//	}
//	else
//	{
//		return false;
//	}
//}
//
//template <class Type>
//Stack<Type>& Stack<Type>::operator=(const Stack<Type>& st)
//{
//	if (this == &st)
//	{
//		return *this;
//	}
//	delete[] items;
//	stacksize = st.stacksize;
//	top = st.top;
//	items = new Type[stacksize];
//	for (int i = 0; i < top; i++)
//	{
//		items[i] = st.items[i];
//	}
//	return *this;
//}
//#endif // !STCKTP1_H_